/*
 * Copyright (C) 2005-2011 MaNGOS <http://www.getmangos.com/>
 *
 * Copyright (C) 2008-2011 Trinity <http://www.trinitycore.org/>
 *
 * Copyright (C) 2010-2011 ArkCORE <http://www.arkania.net/>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include "gamePCH.h"
#include "MapManager.h"
#include "InstanceSaveMgr.h"
#include "DatabaseEnv.h"
#include "Log.h"
#include "ObjectAccessor.h"
#include "Transport.h"
#include "GridDefines.h"
#include "MapInstanced.h"
#include "InstanceScript.h"
#include "DestinationHolderImp.h"
#include "Config.h"
#include "World.h"
#include "CellImpl.h"
#include "Corpse.h"
#include "ObjectMgr.h"
#include "Language.h"
#include "WorldPacket.h"
#include "Group.h"

extern GridState* si_GridStates[]; // debugging code, should be deleted some day

MapManager::MapManager() {
	i_gridCleanUpDelay = sWorld->getIntConfig(CONFIG_INTERVAL_GRIDCLEAN);
	i_timer.SetInterval(sWorld->getIntConfig(CONFIG_INTERVAL_MAPUPDATE));
}

MapManager::~MapManager() {
}

void MapManager::Initialize() {
	Map::InitStateMachine();

	// debugging code, should be deleted some day
	{
		for (uint8 i = 0; i < MAX_GRID_STATE; ++i)
			i_GridStates[i] = si_GridStates[i];

		i_GridStateErrorCount = 0;
	}
	int num_threads(sWorld->getIntConfig(CONFIG_NUMTHREADS));
	// Start mtmaps if needed.
	if (num_threads > 0 && m_updater.activate(num_threads) == -1)
		abort();
}

void MapManager::InitializeVisibilityDistanceInfo() {
	for (MapMapType::iterator iter = i_maps.begin(); iter != i_maps.end();
			++iter)
		(*iter).second->InitVisibilityDistance();
}

// debugging code, should be deleted some day
void MapManager::checkAndCorrectGridStatesArray() {
	bool ok = true;
	for (int i = 0; i < MAX_GRID_STATE; i++) {
		if (i_GridStates[i] != si_GridStates[i]) {
			sLog->outError(
					"MapManager::checkGridStates(), GridState: si_GridStates is currupt !!!");
			ok = false;
			si_GridStates[i] = i_GridStates[i];
		}
#ifdef ARKCORE_DEBUG
		// inner class checking only when compiled with debug
		if (!si_GridStates[i]->checkMagic())
		{
			ok = false;
			si_GridStates[i]->setMagic();
		}
#endif
	}
	if (!ok)
		++i_GridStateErrorCount;
}

Map* MapManager::_createBaseMap(uint32 id) {
	Map *m = _findMap(id);

	if (m == NULL) {
		ACE_GUARD_RETURN(ACE_Thread_Mutex, Guard, Lock, NULL);

		const MapEntry* entry = sMapStore.LookupEntry(id);
		if (entry && entry->Instanceable()) {
			m = new MapInstanced(id, i_gridCleanUpDelay);
		} else {
			m = new Map(id, i_gridCleanUpDelay, 0, REGULAR_DIFFICULTY);
		}
		i_maps[id] = m;
	}

	ASSERT(m != NULL);
	return m;
}

Map* MapManager::CreateMap(uint32 id, const WorldObject* obj,
		uint32 /*instanceId*/) {
	ASSERT(obj);
	//if (!obj->IsInWorld()) sLog->outError("GetMap: called for map %d with object (typeid %d, guid %d, mapid %d, instanceid %d) who is not in world!", id, obj->GetTypeId(), obj->GetGUIDLow(), obj->GetMapId(), obj->GetInstanceId());
	Map *m = _createBaseMap(id);

	if (m && (obj->GetTypeId() == TYPEID_PLAYER) && m->Instanceable())
		m = ((MapInstanced*) m)->CreateInstance(id, (Player*) obj);

	return m;
}

Map* MapManager::FindMap(uint32 mapid, uint32 instanceId) const {
	Map *map = _findMap(mapid);
	if (!map)
		return NULL;

	if (!map->Instanceable())
		return instanceId == 0 ? map : NULL;

	return ((MapInstanced*) map)->FindMap(instanceId);
}

bool MapManager::CanPlayerEnter(uint32 mapid, Player* player, bool loginCheck) {
	MapEntry const* entry = sMapStore.LookupEntry(mapid);
	if (!entry)
		return false;

	if (!entry->IsDungeon())
		return true;

	InstanceTemplate const* instance = sObjectMgr->GetInstanceTemplate(mapid);
	if (!instance)
		return false;

	Difficulty targetDifficulty = player->GetDifficulty(entry->IsRaid());
	//The player has a heroic mode and tries to enter into instance which has no a heroic mode
	MapDifficulty const* mapDiff = GetMapDifficultyData(entry->MapID,
			targetDifficulty);
	if (!mapDiff) {
		// Send aborted message for dungeons
		if (entry->IsNonRaidDungeon()) {
			player->SendTransferAborted(mapid, TRANSFER_ABORT_DIFFICULTY,
					player->GetDungeonDifficulty());
			return false;
		} else
			// attempt to downscale
			mapDiff = GetDownscaledMapDifficultyData(entry->MapID,
					targetDifficulty);
	}

	//Bypass checks for GMs
	if (player->isGameMaster())
		return true;

	char const* mapName = entry->name;

	Group* group = player->GetGroup();
	if (entry->IsRaid()) {
		// can only enter in a raid group
		if ((!group || !group->isRaidGroup())
				&& !sWorld->getBoolConfig(CONFIG_INSTANCE_IGNORE_RAID)) {
			// probably there must be special opcode, because client has this string constant in GlobalStrings.lua
			// TODO: this is not a good place to send the message
			player->GetSession()->SendAreaTriggerMessage(
					player->GetSession()->GetArkCoreString(
							LANG_INSTANCE_RAID_GROUP_ONLY), mapName);
			sLog->outDebug(
					LOG_FILTER_MAPS,
					"MAP: Player '%s' must be in a raid group to enter instance '%s'",
					player->GetName(), mapName);
			return false;
		}
	}

	if (!player->isAlive()) {
		if (Corpse* corpse = player->GetCorpse()) {
			// let enter in ghost mode in instance that connected to inner instance with corpse
			uint32 corpseMap = corpse->GetMapId();
			do {
				if (corpseMap == mapid)
					break;

				InstanceTemplate const* instance =
						ObjectMgr::GetInstanceTemplate(corpseMap);
				corpseMap = instance ? instance->parent : 0;
			} while (corpseMap);

			if (!corpseMap) {
				WorldPacket data(SMSG_CORPSE_NOT_IN_INSTANCE);
				player->GetSession()->SendPacket(&data);
				sLog->outDebug(
						LOG_FILTER_MAPS,
						"MAP: Player '%s' does not have a corpse in instance '%s' and cannot enter.",
						player->GetName(), mapName);
				return false;
			}
			sLog->outDebug(
					LOG_FILTER_MAPS,
					"MAP: Player '%s' has corpse in instance '%s' and can enter.",
					player->GetName(), mapName);
		} else
			sLog->outDebug(
					LOG_FILTER_MAPS,
					"Map::CanPlayerEnter - player '%s' is dead but does not have a corpse!",
					player->GetName());
	}

	//Get instance where player's group is bound & its map
	if (group) {
		InstanceGroupBind* boundInstance = group->GetBoundInstance(entry);
		if (boundInstance && boundInstance->save)
			if (Map * boundMap = sMapMgr->FindMap(mapid,
					boundInstance->save->GetInstanceId()))
				if (!loginCheck && !boundMap->CanEnter(player))
					return false;
		/*
		 This check has to be moved to InstanceMap::CanEnter()
		 // Player permanently bounded to different instance than groups one
		 InstancePlayerBind* playerBoundedInstance = player->GetBoundInstance(mapid, player->GetDifficulty(entry->IsRaid()));
		 if (playerBoundedInstance && playerBoundedInstance->perm && playerBoundedInstance->save &&
		 boundedInstance->save->GetInstanceId() != playerBoundedInstance->save->GetInstanceId())
		 {
		 //TODO: send some kind of error message to the player
		 return false;
		 }*/
	}

	// players are only allowed to enter 5 instances per hour
	if (entry->IsDungeon()
			&& (!player->GetGroup()
					|| (player->GetGroup() && !player->GetGroup()->isLFGGroup()))) {
		uint32 instaceIdToCheck = 0;
		if (InstanceSave* save = player->GetInstanceSave(mapid, entry->IsRaid()))
			instaceIdToCheck = save->GetInstanceId();

		// instanceId can never be 0 - will not be found
		if (!player->CheckInstanceCount(instaceIdToCheck)) {
			player->SendTransferAborted(mapid,
					TRANSFER_ABORT_TOO_MANY_INSTANCES);
			return false;
		}
	}

	//Other requirements
	return player->Satisfy(
			sObjectMgr->GetAccessRequirement(mapid, targetDifficulty), mapid, true);
		}

void MapManager::Update(uint32 diff) {
	i_timer.Update(diff);
	if (!i_timer.Passed())
		return;

	MapMapType::iterator iter = i_maps.begin();
	for (; iter != i_maps.end(); ++iter) {
		if (m_updater.activated())
			m_updater.schedule_update(*iter->second,
					uint32(i_timer.GetCurrent()));
		else
			iter->second->Update(uint32(i_timer.GetCurrent()));
	}
	if (m_updater.activated())
		m_updater.wait();

	for (iter = i_maps.begin(); iter != i_maps.end(); ++iter)
		iter->second->DelayedUpdate(uint32(i_timer.GetCurrent()));

	sObjectAccessor->Update(uint32(i_timer.GetCurrent()));
	for (TransportSet::iterator iter = m_Transports.begin();
			iter != m_Transports.end(); ++iter)
		(*iter)->Update(uint32(i_timer.GetCurrent()));

	i_timer.SetCurrent(0);
}

void MapManager::DoDelayedMovesAndRemoves() {
}

bool MapManager::ExistMapAndVMap(uint32 mapid, float x, float y) {
	GridPair p = Trinity::ComputeGridPair(x, y);

	int gx = 63 - p.x_coord;
	int gy = 63 - p.y_coord;

	return Map::ExistMap(mapid, gx, gy) && Map::ExistVMap(mapid, gx, gy);
}

bool MapManager::IsValidMAP(uint32 mapid, bool startUp) {
	MapEntry const* mEntry = sMapStore.LookupEntry(mapid);

	if (startUp)
		return mEntry ? true : false;
	else
		return mEntry
				&& (!mEntry->IsDungeon()
						|| sObjectMgr->GetInstanceTemplate(mapid));

	// TODO: add check for battleground template
}

void MapManager::UnloadAll() {
	for (TransportSet::iterator i = m_Transports.begin();
			i != m_Transports.end(); ++i) {
		(*i)->RemoveFromWorld();
		delete *i;
	}

	for (MapMapType::iterator iter = i_maps.begin(); iter != i_maps.end();) {
		iter->second->UnloadAll();
		delete iter->second;
		i_maps.erase(iter++);
	}

	if (m_updater.activated())
		m_updater.deactivate();

	Map::DeleteStateMachine();
}

uint32 MapManager::GetNumInstances() {
	ACE_GUARD_RETURN(ACE_Thread_Mutex, Guard, Lock, 0);

	uint32 ret = 0;
	for (MapMapType::iterator itr = i_maps.begin(); itr != i_maps.end();
			++itr) {
		Map *map = itr->second;
		if (!map->Instanceable())
			continue;
		MapInstanced::InstancedMaps &maps =
				((MapInstanced *) map)->GetInstancedMaps();
		for (MapInstanced::InstancedMaps::iterator mitr = maps.begin();
				mitr != maps.end(); ++mitr)
			if (mitr->second->IsDungeon())
				ret++;
	}
	return ret;
}

uint32 MapManager::GetNumPlayersInInstances() {
	ACE_GUARD_RETURN(ACE_Thread_Mutex, Guard, Lock, 0);

	uint32 ret = 0;
	for (MapMapType::iterator itr = i_maps.begin(); itr != i_maps.end();
			++itr) {
		Map *map = itr->second;
		if (!map->Instanceable())
			continue;
		MapInstanced::InstancedMaps &maps =
				((MapInstanced *) map)->GetInstancedMaps();
		for (MapInstanced::InstancedMaps::iterator mitr = maps.begin();
				mitr != maps.end(); ++mitr)
			if (mitr->second->IsDungeon())
				ret += ((InstanceMap*) mitr->second)->GetPlayers().getSize();
	}
	return ret;
}

void MapManager::InitInstanceIds() {
	_nextInstanceId = 1;

	QueryResult result = CharacterDatabase.Query(
			"SELECT MAX(id) FROM instance");
	if (result) {
		uint32 maxId = (*result)[0].GetUInt32();

		// Resize to multiples of 32 (vector<bool> allocates memory the same way)
		_instanceIds.resize((maxId / 32) * 32 + (maxId % 32 > 0 ? 32 : 0));
	}
}

void MapManager::RegisterInstanceId(uint32 instanceId) {
	// Allocation and sizing was done in InitInstanceIds()
	_instanceIds[instanceId] = true;
}

uint32 MapManager::GenerateInstanceId() {
	uint32 newInstanceId = _nextInstanceId;

	// Find the lowest available id starting from the current NextInstanceId (which should be the lowest according to the logic in FreeInstanceId()
	for (uint32 i = ++_nextInstanceId; i < 0xFFFFFFFF; ++i) {
		if ((i < _instanceIds.size() && !_instanceIds[i])
				|| i >= _instanceIds.size()) {
			_nextInstanceId = i;
			break;
		}
	}

	if (newInstanceId == _nextInstanceId) {
		sLog->outError(
				"Instance ID overflow!! Can't continue, shutting down server. ");
		World::StopNow(ERROR_EXIT_CODE);
	}

	// Allocate space if necessary
	if (newInstanceId >= uint32(_instanceIds.size())) {
		// Due to the odd memory allocation behavior of vector<bool> we match size to capacity before triggering a new allocation
		if (_instanceIds.size() < _instanceIds.capacity()) {
			_instanceIds.resize(_instanceIds.capacity());
		} else
			_instanceIds.resize(
					(newInstanceId / 32) * 32
							+ (newInstanceId % 32 > 0 ? 32 : 0));
	}

	_instanceIds[newInstanceId] = true;

	return newInstanceId;
}

void MapManager::FreeInstanceId(uint32 instanceId) {
	// If freed instance id is lower than the next id available for new instances, use the freed one instead
	if (instanceId < _nextInstanceId)
		SetNextInstanceId(instanceId);

	_instanceIds[instanceId] = false;
}
